package com.fenqing.comics.utils;

import com.fenqing.comics.commons.Functions;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * @author fenqing
 */
public class MapUtils {


    /**
     * 将一个Map转换成另一个Map，转换规则为：将原Map的key作为新Map的key，原Map的value作为新Map的value
     * @param source 原Map
     * @param keyMapper key转换规则
     * @param valueMapper value转换规则
     * @return 转换后的map
     * @param <SK> 源map的key类型
     * @param <SV> 源map的value类型
     * @param <TK> 目标map的key类型
     * @param <TV> 目标map的value类型
     */
    public static <SK, SV, TK, TV> Map<TK, TV> of(
            Map<SK, SV> source,
            Function<SK, TK> keyMapper,
            Function<SV, TV> valueMapper
    ) {
        Set<Map.Entry<SK, SV>> entries = source.entrySet();
        return entries
                .stream()
                .collect(
                        Collectors.toMap(
                                entity -> keyMapper.apply(entity.getKey()),
                                entity -> valueMapper.apply(entity.getValue()),
                                Functions.repeat()
                        )
                );
    }

    /**
     * 将一个Map转换为另一个Map，转换规则为：
     * @param source 源map
     * @param keyMapper key转换规则
     * @return 转换后的map
     * @param <SK> 源map的key类型
     * @param <SV> 源map的value类型
     * @param <TK> 目标map的key类型
     */
    public static <SK, SV, TK> Map<TK, SV> of(
            Map<SK, SV> source,
            Function<SK, TK> keyMapper
    ) {
        return MapUtils.of(source, keyMapper, Function.identity());
    }

    public static <T> Map<T, Integer> count(List<T> list) {
        return list
                .stream()
                .collect(Collectors.toMap(
                        Function.identity(),
                        v -> 1,
                        Integer::sum
                ));
    }

}
